Explaining MVVM, Protocol-Oriented Programming, and Dependency Injection

Course: iOS App Development

Topic: MVVM, Protocol-Oriented Programming, and Dependency Injection

Course Link: iOS App Development Training

Demo Link: Register for Course Demo

Website: JustAcademy

1. Introduction to Software Architecture in iOS Development

Software architecture defines how different components of an application are organized, connected, and maintained. In iOS development, choosing an appropriate architecture helps developers create applications that are scalable, reusable, testable, and easier to maintain.

As an iOS application becomes larger, writing all the code inside a single ViewController or SwiftUI view can create problems. UI code, business logic, API communication, and database operations become mixed together, making debugging and future development difficult.

To solve these problems, developers use architectural patterns and programming principles such as:

• MVVM: Separates the Model, View, and ViewModel.
• Protocol-Oriented Programming: Uses protocols to define reusable capabilities and behavior.
• Dependency Injection: Provides required objects and services to components instead of creating dependencies internally.

Why These Concepts Are Important

• Improve code organization and readability.
• Reduce unnecessary dependencies between components.
• Make application features reusable.
• Improve unit testing and debugging.
• Support large-scale application development.
• Make applications easier to extend and maintain.

2. Understanding MVVM Architecture

MVVM stands for Model-View-ViewModel. It is a software architectural pattern that separates an application's data, user interface, and presentation logic into three main components.

MVVM is widely used in iOS development with SwiftUI because SwiftUI can automatically update the interface when observed application state changes.

Three Main Components of MVVM

MVVM Architecture Diagram

        USER
          |
          v
       VIEW
  (SwiftUI Interface)
          |
          | User Actions
          v
      VIEWMODEL
 (Presentation Logic)
          |
          | Data Requests
          v
        MODEL
 (Data and Business Logic)
          |
          v
    API / DATABASE
          |
          v
      VIEWMODEL
          |
          | Updated State
          v
         VIEW

How MVVM Works

1. The user interacts with the application interface.
2. The View sends an action to the ViewModel.
3. The ViewModel processes the action.
4. The ViewModel requests data from a model or service.
5. The Model or service retrieves or updates information.
6. The ViewModel updates its observable state.
7. The View automatically reflects the updated information.

3. Understanding the Model in MVVM

The Model represents the data used by an application. It defines the structure of information and may include domain-related business rules.

Models should generally remain independent of the user interface. They should describe application data rather than control how information is displayed.

Example: Creating a User Model

import Foundation

struct User: Identifiable, Codable {
    let id: Int
    var name: String
    var email: String
    var phone: String
}

Explanation

• struct User: Defines a user data structure.
• Identifiable: Allows SwiftUI to identify individual user records.
• Codable: Supports JSON encoding and decoding.
• id: Stores the unique user identifier.
• name: Stores the user's name.
• email: Stores the user's email address.
• phone: Stores the contact number.

4. Understanding the View in MVVM

The View represents the user interface of an application. It displays information and allows users to interact with application features.

In modern iOS development, SwiftUI provides a declarative approach to creating views. Developers describe what the interface should display based on the current state.

Responsibilities of a View

• Display application information.
• Collect user input.
• Show buttons, forms, and navigation elements.
• Observe relevant ViewModel state.
• Send user actions to the ViewModel.
• Display loading and error states.

Example: UserView.swift

import SwiftUI

struct UserView: View {

    @StateObject private var viewModel =
        UserViewModel()

    var body: some View {

        NavigationStack {
            VStack(spacing: 20) {

                Text("User Management")
                    .font(.largeTitle)
                    .bold()

                Button("Load User") {
                    Task {
                        await viewModel.loadUser()
                    }
                }

                if viewModel.isLoading {
                    ProgressView("Loading...")
                }

                if let user = viewModel.user {
                    Text(user.name)
                    Text(user.email)
                    Text(user.phone)
                }

                if let error = viewModel.errorMessage {
                    Text(error)
                        .foregroundStyle(.red)
                }
            }
            .padding()
            .navigationTitle("Users")
        }
    }
}

5. Understanding the ViewModel in MVVM

The ViewModel acts as an intermediary between the View and the application's data layer. It receives user actions, performs presentation-related operations, communicates with services, and exposes the resulting state to the View.

Responsibilities of a ViewModel

• Manage screen-related application state.
• Process user actions.
• Call API and database services.
• Prepare information for display.
• Handle loading and error states.
• Coordinate data updates.
• Keep business and presentation logic out of the View.

Example: UserViewModel.swift

import Foundation

@MainActor
class UserViewModel: ObservableObject {

    @Published var user: User?
    @Published var isLoading = false
    @Published var errorMessage: String?

    func loadUser() async {

        isLoading = true
        errorMessage = nil

        defer {
            isLoading = false
        }

        do {
            let url = URL(
                string: "https://jsonplaceholder.typicode.com/users/1"
            )!

            let (data, _) =
                try await URLSession.shared.data(
                    from: url
                )

            user = try JSONDecoder().decode(
                User.self,
                from: data
            )

        } catch {
            errorMessage = "Unable to load user information."
        }
    }
}

Note: This example demonstrates the basic MVVM flow. In a production application, network communication should be moved into a separate service or repository rather than being implemented directly inside the ViewModel.

6. Observable State Management in SwiftUI

State management allows SwiftUI views to react to changes in application data.

Important Property Wrappers

Example of Published Properties

import Foundation

class CounterViewModel: ObservableObject {

    @Published var count = 0

    func increment() {
        count += 1
    }

    func decrement() {
        count -= 1
    }
}

Using the ViewModel in SwiftUI

import SwiftUI

struct CounterView: View {

    @StateObject private var viewModel =
        CounterViewModel()

    var body: some View {

        VStack(spacing: 20) {

            Text("Count: \(viewModel.count)")
                .font(.largeTitle)

            Button("Increase") {
                viewModel.increment()
            }

            Button("Decrease") {
                viewModel.decrement()
            }
        }
    }
}

When the count changes, SwiftUI observes the published property and updates the relevant interface.

7. Advantages of MVVM Architecture

• Separation of Concerns: UI and application logic remain separate.
• Maintainability: Individual components can be modified independently.
• Testability: ViewModel logic can be tested without launching the complete interface.
• Reusability: ViewModels and services can support multiple screens where appropriate.
• Scalability: Supports larger applications with multiple features.
• Readability: Makes the codebase easier for development teams to understand.

8. Understanding Protocol-Oriented Programming (POP)

Protocol-Oriented Programming is a programming approach in Swift that focuses on defining capabilities through protocols rather than relying primarily on class inheritance.

A protocol defines a blueprint of methods, properties, and other requirements. Classes, structures, and enumerations can adopt protocols and provide their own implementations.

Swift also supports protocol extensions, which allow developers to provide reusable default implementations for protocol requirements.

Why Protocol-Oriented Programming Is Used

• Encourages reusable and flexible code.
• Reduces dependence on class inheritance.
• Allows structures, classes, and enumerations to share capabilities.
• Improves abstraction.
• Supports dependency inversion.
• Makes services easier to replace during testing.

9. Understanding Protocols in Swift

A protocol defines what a conforming type must provide. It specifies requirements without necessarily defining the complete implementation.

Basic Protocol Syntax

protocol Vehicle {

    var brand: String { get }

    func startEngine()
    func stopEngine()
}

Implementing a Protocol

struct Car: Vehicle {

    var brand: String

    func startEngine() {
        print("Car engine started")
    }

    func stopEngine() {
        print("Car engine stopped")
    }
}

struct Bike: Vehicle {

    var brand: String

    func startEngine() {
        print("Bike engine started")
    }

    func stopEngine() {
        print("Bike engine stopped")
    }
}

Explanation

• Vehicle: Defines a common protocol.
• brand: Requires a readable property.
• startEngine(): Requires an engine-start operation.
• stopEngine(): Requires an engine-stop operation.
• Car: Provides one implementation.
• Bike: Provides another implementation.

10. Protocol Extensions and Default Implementations

Protocol extensions allow developers to add reusable methods and computed properties to protocols. They can also provide default implementations for protocol requirements.

Example

protocol NotificationService {

    func sendNotification()
}

extension NotificationService {

    func logNotification() {
        print("Notification process started")
    }
}

struct EmailNotification: NotificationService {

    func sendNotification() {
        print("Email notification sent")
    }
}

struct PushNotification: NotificationService {

    func sendNotification() {
        print("Push notification sent")
    }
}

Using Protocol Extension Methods

let email = EmailNotification()

email.sendNotification()
email.logNotification()

let push = PushNotification()

push.sendNotification()
push.logNotification()

Benefits of Protocol Extensions

• Reduce duplicate code.
• Provide shared functionality.
• Allow types to customize default behavior.
• Improve code reusability.
• Support modular application design.

11. Protocol-Oriented Programming vs Object-Oriented Programming

12. Using Protocol-Oriented Programming in iOS Applications

Protocols are particularly useful when different parts of an application need to communicate without knowing the concrete implementation of another component.

Example: Authentication Protocol

protocol AuthenticationService {

    func login(
        email: String,
        password: String
    ) async throws -> User

    func logout() async throws
}

Implementing Authentication Service

struct FirebaseAuthService: AuthenticationService {

    func login(
        email: String,
        password: String
    ) async throws -> User {

        // Firebase authentication implementation
        throw NSError(
            domain: "Example",
            code: 1
        )
    }

    func logout() async throws {

        // Firebase sign-out implementation
    }
}

This is a structural example of protocol conformance. In a real application, the implementation should call Firebase Authentication and map its authenticated user into the application's User model.

Advantages

• The application can use different authentication providers.
• The ViewModel does not need to know authentication implementation details.
• Mock authentication services can be created for testing.
• Services can be replaced without changing the ViewModel's public interface.

13. Understanding Dependency Injection (DI)

Dependency Injection is a software design technique in which an object receives the services or objects it needs from an external source instead of creating those dependencies internally.

A dependency is any object or service that another component requires to perform its work.

Example of a Dependency

Suppose a LoginViewModel needs an authentication service to verify user credentials. The authentication service is a dependency of the LoginViewModel.

Without Dependency Injection, the ViewModel may create its own authentication service. This makes the ViewModel tightly coupled to that implementation.

With Dependency Injection, the authentication service is provided from outside, allowing the application to use Firebase, a mock service, or another implementation.

Why Dependency Injection Is Important

• Reduces tight coupling between components.
• Makes dependencies easier to replace.
• Improves unit testing.
• Supports reusable services.
• Improves flexibility and maintainability.
• Helps organize large application architectures.

14. Understanding Dependency Injection with an Example

Consider a ViewModel that requires a network service to retrieve user information.

Without Dependency Injection

class UserViewModel {

    private let service = APIService()

    func loadUser() async throws -> User {
        try await service.fetchUser()
    }
}

Problem: The ViewModel directly creates APIService. Replacing the real API service with a mock service for testing becomes more difficult.

With Dependency Injection

class UserViewModel {

    private let service: APIService

    init(service: APIService) {
        self.service = service
    }

    func loadUser() async throws -> User {
        try await service.fetchUser()
    }
}

Now the dependency is passed through the initializer. However, using a protocol instead of the concrete APIService type provides even greater flexibility.

15. Types of Dependency Injection

There are three commonly discussed ways to provide dependencies to objects.

15.1 Constructor Injection

Constructor injection, also called initializer injection, provides dependencies when an object is created.

class UserViewModel {

    private let service: UserService

    init(service: UserService) {
        self.service = service
    }
}

Advantages: Dependencies are explicit, required dependencies cannot be forgotten when constructing the object, and testing becomes easier.

15.2 Property Injection

Property injection provides a dependency through a property after the object has been created.

class UserViewModel {

    var service: UserService?
}

Advantages: Useful for optional or late-provided dependencies.

Limitation: The object may be used before its required dependency has been assigned.

15.3 Method Injection

Method injection passes a dependency directly into a method when that method needs it.

class ReportViewModel {

    func generateReport(
        using service: ReportService
    ) {
        service.generate()
    }
}

Advantages: Suitable for temporary dependencies that are needed only for a particular operation.

Comparison of Dependency Injection Types

16. Combining Protocol-Oriented Programming and Dependency Injection

Protocols and Dependency Injection work especially well together. Protocols define what a service must do, while Dependency Injection provides a particular implementation of that service.

Step 1: Create a Service Protocol

protocol UserService {

    func fetchUser() async throws -> User
}

Step 2: Create a Real API Implementation

struct RemoteUserService: UserService {

    func fetchUser() async throws -> User {

        let url = URL(
            string: "https://jsonplaceholder.typicode.com/users/1"
        )!

        let (data, response) =
            try await URLSession.shared.data(
                from: url
            )

        guard let httpResponse =
            response as? HTTPURLResponse,
            (200...299).contains(
                httpResponse.statusCode
            ) else {
            throw URLError(.badServerResponse)
        }

        return try JSONDecoder().decode(
            User.self,
            from: data
        )
    }
}

Step 3: Inject the Protocol into the ViewModel

import Foundation

@MainActor
class UserViewModel: ObservableObject {

    @Published var user: User?
    @Published var errorMessage: String?

    private let service: any UserService

    init(service: any UserService) {
        self.service = service
    }

    func loadUser() async {

        do {
            user = try await service.fetchUser()
        } catch {
            errorMessage = "Unable to fetch user."
        }
    }
}

Step 4: Provide the Dependency from the View

import SwiftUI

struct UserScreen: View {

    @StateObject private var viewModel: UserViewModel

    init() {
        _viewModel = StateObject(
            wrappedValue: UserViewModel(
                service: RemoteUserService()
            )
        )
    }

    var body: some View {

        VStack(spacing: 15) {

            Button("Fetch User") {
                Task {
                    await viewModel.loadUser()
                }
            }

            if let user = viewModel.user {
                Text(user.name)
                Text(user.email)
            }

            if let error = viewModel.errorMessage {
                Text(error)
                    .foregroundStyle(.red)
            }
        }
        .padding()
    }
}

This implementation combines all three concepts:

• MVVM: UserScreen and UserViewModel are separated.
• POP: UserService defines the required service behavior.
• DI: RemoteUserService is injected into UserViewModel.

17. Creating Mock Services for Unit Testing

One of the biggest advantages of protocols and dependency injection is the ability to replace real services with mock implementations.

A mock service provides controlled test data without requiring an actual API request.

Creating a Mock User Service

struct MockUserService: UserService {

    func fetchUser() async throws -> User {

        return User(
            id: 1,
            name: "Test User",
            email: "[email protected]",
            phone: "1234567890"
        )
    }
}

Using the Mock Service

let mockService = MockUserService()

let viewModel = UserViewModel(
    service: mockService
)

Task {
    await viewModel.loadUser()
}

The ViewModel receives test data without contacting the actual server.

Benefits of Mock Services

• Tests can run without internet access.
• Test results are more predictable.
• API usage is reduced during testing.
• Different success and failure scenarios can be simulated.
• Business and presentation logic can be tested independently.

18. Understanding Dependency Inversion Principle

The Dependency Inversion Principle (DIP) is one of the SOLID software design principles. It states that high-level modules should not depend directly on low-level implementation details. Both should depend on abstractions.

Example

protocol PaymentService {
    func makePayment(amount: Double)
}

struct CreditCardPayment: PaymentService {

    func makePayment(amount: Double) {
        print("Credit card payment: \(amount)")
    }
}

struct UpiPayment: PaymentService {

    func makePayment(amount: Double) {
        print("UPI payment: \(amount)")
    }
}

class CheckoutViewModel {

    private let paymentService: any PaymentService

    init(paymentService: any PaymentService) {
        self.paymentService = paymentService
    }

    func checkout(amount: Double) {
        paymentService.makePayment(amount: amount)
    }
}

Using Different Implementations

let creditCard = CheckoutViewModel(
    paymentService: CreditCardPayment()
)

let upi = CheckoutViewModel(
    paymentService: UpiPayment()
)

creditCard.checkout(amount: 1000)
upi.checkout(amount: 1000)

The CheckoutViewModel does not need to know whether a credit card or UPI implementation performs the payment. It depends on the PaymentService abstraction.

19. Understanding a Dependency Container

In larger applications, many ViewModels and services may require different dependencies. Creating all dependencies manually inside individual views can become difficult to manage.

A dependency container centralizes the creation and configuration of shared services.

Example: AppDependencyContainer

final class AppDependencyContainer {

    let userService: any UserService

    init() {
        self.userService = RemoteUserService()
    }

    func makeUserViewModel() -> UserViewModel {
        UserViewModel(
            service: userService
        )
    }
}

Using the Dependency Container

let container = AppDependencyContainer()

let userViewModel =
    container.makeUserViewModel()

Advantages

• Centralizes dependency creation.
• Reduces repeated initialization code.
• Makes application configuration easier.
• Supports different configurations for development and production.
• Allows test dependencies to be substituted.

20. Applying MVVM, POP, and DI in a Real iOS Project

Consider an e-commerce application where users can browse products, view details, add items to a cart, and complete purchases.

Application Components

Integrated Architecture

              SwiftUI View
                   |
                   v
             ProductViewModel
                   |
                   v
            ProductService
               Protocol
                   |
          -------------------
          |                 |
          v                 v
   Remote Service      Mock Service
          |                 |
          v                 v
       REST API         Test Data

          Dependency Container
                   |
                   v
        Provides Service Instance

21. Common Mistakes in MVVM, POP, and DI

MVVM Mistakes

• Writing all business logic directly inside SwiftUI views.
• Making ViewModels responsible for unrelated features.
• Creating oversized ViewModels.
• Mixing API networking code with interface code.
• Using unnecessary observable state.

POP Mistakes

• Creating protocols without a clear abstraction requirement.
• Adding too many unnecessary protocol requirements.
• Using protocol extensions without understanding method dispatch behavior.
• Creating overly complicated protocol inheritance structures.
• Ignoring the actual responsibilities of conforming types.

DI Mistakes

• Creating dependencies internally despite using injection elsewhere.
• Passing too many unrelated dependencies into one ViewModel.
• Using optional dependencies when they are actually required.
• Creating unnecessary global service instances.
• Making dependency containers unnecessarily complicated.

22. Best Practices for Professional iOS Development

• Keep SwiftUI views focused on presentation.
• Move presentation logic into ViewModels.
• Use separate services for API and database operations.
• Define protocols around meaningful service boundaries.
• Prefer initializer injection for required dependencies.
• Use mock implementations for unit testing.
• Keep models independent of UI frameworks whenever practical.
• Use clear naming conventions for protocols and implementations.
• Avoid unnecessary abstractions in small applications.
• Use dependency containers when application complexity justifies them.
• Apply appropriate concurrency and main-actor isolation for UI state.
• Keep dependencies explicit and easy to understand.

23. Practical Project: User Management Application Using MVVM, POP, and DI

The practical project involves developing a User Management Application that retrieves user information from a REST API and displays it through a SwiftUI interface.

Project Objectives

• Build an application using MVVM architecture.
• Create reusable service protocols.
• Implement API communication using URLSession.
• Use dependency injection to provide services.
• Implement loading and error states.
• Create mock services for testing.
• Separate interface, data, and business logic.

Project Development Steps

1. Create a new iOS application in Xcode.
2. Create a User model using Codable.
3. Define a UserService protocol.
4. Create a RemoteUserService implementation.
5. Develop a UserViewModel.
6. Inject the service through the ViewModel initializer.
7. Create a SwiftUI UserScreen.
8. Display API information in the interface.
9. Create a MockUserService.
10. Test the application with both real and mock data.

Expected Project Output

Students should develop an iOS application with clearly separated UI and business logic, reusable protocol-based services, and injectable dependencies. The application should be easy to test and maintain.

24. Practice Exercises

1. Create a simple iOS application using MVVM architecture.
2. Develop a User model using Swift structures.
3. Create a ViewModel that manages user information.
4. Build a SwiftUI interface that observes ViewModel properties.
5. Create a protocol for authentication operations.
6. Implement two different types conforming to the same protocol.
7. Create a protocol extension with a default implementation.
8. Implement constructor-based dependency injection.
9. Compare property injection and method injection.
10. Create a mock API service for unit testing.
11. Build a dependency container for application services.
12. Integrate MVVM, POP, and DI into one application.
13. Write unit tests for ViewModel functionality.

25. Interview Questions and Answers

Q1. What is MVVM architecture?

Answer: MVVM stands for Model-View-ViewModel. It separates application data, user interface, and presentation logic into independent components.

Q2. What is the responsibility of a Model?

Answer: The Model represents application data and domain-related business entities.

Q3. What is the responsibility of a View?

Answer: The View displays information and handles user interactions.

Q4. What is a ViewModel?

Answer: A ViewModel manages presentation logic, handles user actions, communicates with services, and exposes state to the View.

Q5. What is Protocol-Oriented Programming?

Answer: POP is a programming approach that uses protocols to define capabilities and allows different types to provide their own implementations.

Q6. What is a protocol in Swift?

Answer: A protocol defines requirements such as methods, properties, and initializers that conforming types must implement.

Q7. What is a protocol extension?

Answer: A protocol extension adds functionality and can provide default implementations to types that conform to the protocol.

Q8. What is Dependency Injection?

Answer: Dependency Injection is a technique in which an object receives its required dependencies from an external source rather than creating them internally.

Q9. What are the three common types of Dependency Injection?

Answer: Constructor injection, property injection, and method injection.

Q10. What is constructor injection?

Answer: Constructor injection provides required dependencies through an object's initializer.

Q11. Why are protocols useful with Dependency Injection?

Answer: Protocols provide abstractions that allow concrete implementations to be replaced without changing the dependent component.

Q12. What is a mock service?

Answer: A mock service is a test implementation that provides controlled responses without using the actual external service.

Q13. What is the Dependency Inversion Principle?

Answer: It states that high-level and low-level modules should depend on abstractions rather than directly depending on each other's concrete implementations.

Q14. What is the difference between MVVM and MVC?

Answer: MVC organizes an application around Model, View, and Controller, while MVVM introduces a ViewModel to separate presentation logic from the View.

Q15. Why is MVVM popular in SwiftUI?

Answer: MVVM works naturally with SwiftUI's state-driven interface updates and helps separate presentation logic from UI components.

Q16. What is a dependency container?

Answer: A dependency container is an object that creates and provides application dependencies to other components.

Q17. Can structures conform to protocols in Swift?

Answer: Yes. Classes, structures, and enumerations can all conform to Swift protocols.

Q18. What is the difference between @StateObject and @ObservedObject?

Answer: @StateObject is used when a View owns and creates an ObservableObject, while @ObservedObject is used to observe an object supplied from elsewhere.

26. Quick Revision

27. Conclusion

MVVM, Protocol-Oriented Programming, and Dependency Injection are important software design concepts used in professional iOS application development.

MVVM separates the user interface from presentation logic, Protocol-Oriented Programming creates reusable abstractions, and Dependency Injection makes application components flexible and easier to test.

When these concepts are combined, developers can build modular, scalable, maintainable, and testable applications using Swift and SwiftUI.

Understanding these concepts also prepares iOS developers to work with real-world application architectures, API integrations, database services, authentication systems, and large development projects.

Learn iOS App Development with JustAcademy

Develop practical skills in Swift, SwiftUI, MVVM architecture, protocol-oriented programming, dependency injection, API integration, and professional iOS application development.

Course Page: Explore iOS App Development Training

Course Demo: Register for a Free Course Demo

JustAcademy Website: Visit JustAcademy